In [6]: 
import numpy as np
In [11]: 
F=67e6
w = 2 *np.pi * F
Zo = 50
R = 127
L = 200e-9

XInd = complex(0, w*L)
ZL = R * XInd / (R+XInd)
ZL
Out[11]:
(38.77510867003023+58.48871471250831j)
In [13]: 
Kl = (ZL-Zo)/(ZL+Zo)
Kl
Out[13]:
(0.21451509450068992+0.5175099556283658j)
In [14]: 
d = 6
B = 2 * np.pi * F/(0.66*3e8)
B
Out[14]:
2.126128361520365
In [18]: 
KIn_a=np.exp(complex(0,-2*B*d))
KIn_a
Out[18]:
(0.92836793301607212-0.37166245566032857j)
In [19]: 
KIn = KIn_a*Kl
KIn
Out[19]:
(0.39148795581985896+0.40071244102361125j)
In [17]: 
ZIn = Zo * (1+KIn)/(1-KIn)
ZIn
Out[17]:
(50.000000000178261+4.300598768910977e-10j)
In [21]: 
zl = complex(85,32)
z0 = 50
Kl = (zl-z0)/(zl+z0)
Kl
Out[21]:
(0.29866486570730943+0.1662424022027118j)
In [29]: 
Kl*Kl.conjugate()*250
Out[29]:
(29.209309574523346+0j)
In [51]: 
def V_L(V, Rs, Z0, Zl, n):
    Vf = V*Z0/(Z0+Rs)
    Kl = (Zl - Z0)/(Zl + Z0)
    Ks = (Rs - Z0)/(Rs + Z0)
    
    return (Vf * (1+Kl) * (1 - (Ks*Kl)**n) / (1 - Ks*Kl), Kl, Ks)

v, Kl, Ks = V_L(3.0, 15.0, 88.0, 1000.0, 10000)
v, Kl, Ks
Out[51]:
(2.9556650246305423, 0.8382352941176471, -0.7087378640776699)
In [52]: 
Ks * Kl
Out[52]:
-0.5940890919474586
In [55]: 
(1+Kl)/(1-Ks*Kl)*2.56
Out[55]:
2.9520824003582624
In [54]: 
1+Kl
Out[54]:
1.8382352941176472
In [82]: 
def tick(t):
    return V_L(3.0, 10.0, 100.0, 9999999999999.0, t)

ts = np.arange(30)

figure(figsize=(10,10))
plot(ts*25, map(tick, ts))
axhline(2.0)
axhline(2.919)
ylim(2.8,3.0)
Out[82]:
(2.8, 3.0)
In [99]: 
def tick(r):
    return (V_L(3.0, 10.0+r, 100.0, 9999999999999.0, 1)[0], V_L(3.0, 10.0+r, 100.0, 9999999999999.0, 2)[0])


rs = np.arange(1000)

figure(figsize=(10,10))

plot(rs, map(tick, rs), '-')

axhline(2.0)
#xlim(0,20)
#ylim(1.9,2.1)
Out[99]:
<matplotlib.lines.Line2D at 0x105d985d0>
In [100]: 
def tick(r):
    return V_L(3.0, 10.0, 100.0, r, 2)[0]


rs = np.arange(1000)

figure(figsize=(10,10))

plot(rs, map(tick, rs), 'o')

axhline(2.0)
#xlim(545,555)
#ylim(1.9,2.1)
Out[100]:
<matplotlib.lines.Line2D at 0x105aab310>
In [57]: 
%pylab inline

Populating the interactive namespace from numpy and matplotlib
In [80]: 
def settle_over(V, Rs, Z0, Zl, V_target):
    _, Kl, Ks = V_L(V, Rs, Z0, Zl, 1)
    
    Vf = V * Z0/(Rs+Z0)
    
    t = (V_target-Vf)/Vf
    
    n = (np.log( (t) * (1-Ks*Kl)/(1+Kl)) / np.log(-1*Ks*Kl))
    
    return (n, t, Vf, Ks, Kl)
    
    return (np.log(  (V_target)*(1-Ks*Kl)/(Vf)/(1+Kl) - 1 ) / np.log(Ks*Kl), Vf, Ks, Kl)

settle_over(3.0, 10.0, 100.0, 99999999999, 2.9)
Out[80]:
(14.225563130523863,
 0.06333333333333338,
 2.727272727272727,
 -0.8181818181818182,
 0.9999999980000001)
In [75]: 
16*25
Out[75]:
400
In [102]: 
2*np.pi*(0.241*1e-6)*41e6, 1/(2*np.pi*41e6*44e-12)
Out[102]:
(62.084154020241485, 88.22336091568478)
In [110]: 
Zl = complex(0,62) + (complex(0,-88)*154)/(154+complex(0,-88))
Zl
Out[110]:
(37.90769230769231-4.338461538461544j)
In [111]: 
(Zl-50)/(Zl+50)
Out[111]:
(-0.1347929012885083-0.05600482992008396j)
In [113]: 
1.0/Inf
Out[113]:
0.0
In [117]: 
try:
    x = 1.0/20
except ZeroDivisionError:
    x = Inf
    
x
Out[117]:
0.05
In [124]: 
20*(log10(sinc(1.0/50)) - log10(sinc(1.0/5)))
Out[124]:
0.57350782269122136
In [122]: 
xs = np.arange(100)*np.pi
plot(xs, sinc(xs))
Out[122]:
[<matplotlib.lines.Line2D at 0x105ad9b10>]
In [137]: 
def alpf(Fs, N, f):
    return np.abs(1.0/N*sin(N*np.pi*f/Fs)/sin(np.pi*f/Fs))

def dB(x):
    return 10*np.log(x)

def H_alpf(Fs, N, f):
    return dB(alpf(Fs, N, f))

Fs=200
Fs_disp=10000
freqs=np.arange(Fs)+1

figure(figsize=(10,10))
plot(freqs*Fs_disp/Fs, H_alpf(Fs, 8, freqs))
xlim(0,Fs_disp/2)
ylim(-40,0)
Out[137]:
(-40, 0)
In [140]: 
Fs=200
Fs_disp=100000
freqs=np.arange(Fs)+1

figure(figsize=(10,10))
plot(freqs*Fs_disp/Fs, dB(alpf(Fs, 7, freqs)*alpf(Fs,5,freqs)))
plot(freqs*Fs_disp/Fs, H_alpf(Fs, 7, freqs))
plot(freqs*Fs_disp/Fs, H_alpf(Fs, 5, freqs))

xlim(0,Fs_disp/2)
ylim(-40,0)
Out[140]:
(-40, 0)
In []: